package 函数式编程.使用Stream;

import java.util.Arrays;
import java.util.List;
import java.util.function.IntFunction;

/*
最好的转换方法是使用Stream.toArray(IntFunction)方法。     <A> A[] toArray(IntFunction<A[]> generator);
在我们的示例中，我们将通过以下方式将Java流(Stream)转换为数组(Array)。

我们将使用Stream.toArray(IntFunction)返回所需类型的数组。
使用Stream.toArray(IntFunction)方法，该方法将返回Object[]，然后将其更改为所需的数据类型。
对于整数流，我们可以使用IntStream.toArray()将返回int[]。我们可以用同样的方法LongStream.toArray() 返回long[]和DoubleStream.toArray()返回double[]。
我们可以将流转换为列表，然后将列表转换为数组。要将流(Stream)转换成列表(list)，我们需要在流(Stream)上使用collect(Collectors.toList())，而要将列表(list)转换为数组(Array)，我们可以使用List.toArray方法。
1.Using Stream.toArray(IntFunction)
toArray(IntFunction)方法使用提供的生成器作为IntFunction返回包含此流元素的数组。这种方法是终端操作。

《b.数组构造方法引用》

组成语法格式：TypeName[]::new 例子：
int[]::new 是一个含有一个参数的构造器引用，这个参数就是数组的长度。等价于lambda表达式  x -> new int[x]。

假想存在一个接收int参数的数组构造方法：
IntFunction<int[]> arrayMaker = int[]::new;
int[] array = arrayMaker.apply(10) // 创建数组 int[10]

<A> A[] toArray(IntFunction<A[]> generator);

A[] toArray(IntFunction<A[]> generator) 

参数：将生成器作为IntFunction传递，该函数生成所需类型和所提供长度的新数组。
返回：该方法返回由stream元素组成的数组。
异常：如果此流中任何元素的运行时类型不可分配给生成数组的运行时组件类型，则该方法将抛出ArrayStoreException。

示例1：
在这个例子中，我们将把字符串流转换成字符串数组。

List<String> list = Arrays.asList("A", "B", "C", "D");
String[] strArray = list.stream().toArray(String[]::new); //String[]::new等价于lambda表达式  x -> new String[x]。
for(String s : strArray) {
  System.out.println(s);
} 

输出将是一个B C D。在上面的示例中，我们使用方法引用将IntFunction实例化为toArray方法中的生成器。

现在找到带有lambda表达式的示例。

String[] strArray = list.stream().toArray(size -> new String[size]); 

再找一个例子。
*/
public class Stream转成Array {
   public static void main(String[] args) {
      List<String> list = Arrays.asList("Krishna", "Mahesh", "Kush");
      String[] strArray = list.stream()
      	 .filter(e -> e.startsWith("K"))
      	 //.toArray(size -> new String[size]);
      	 .toArray(String[]::new);//亦可
      for(String s : strArray) {
        System.out.println(s);
      }
   }
} 

//例2：
//在这个例子中，我们将把整数流转换成整数数组。
/*
public class Stream转成Array {
  public static void main(String[] args) {
     List<Integer> list = Arrays.asList(10, 20, 30, 40);
     Integer[] intArray = list.stream()
    	 .map(e -> e * 2)
    	 .toArray(Integer[]::new);
     for(Integer i : intArray) {
       System.out.println(i);
     }
  }
} 
*/
//输出为20 40 60 80。
/*
在上面的例子中，我们使用了方法引用。现在找到带有lambda表达式的代码。

List<Integer> list = Arrays.asList(10, 20, 30, 40);
Integer[] intArray = list.stream()
  .map(e -> e * 2)
  .toArray(size -> new Integer[size]); 

2.Using Stream.toArray()
toArray()方法返回一个包含此流元素的Object数组。

Object[] toArray() 

这种方法是终端操作。

例1：在这个例子中，我们将把一个字符串流转换成字符串数组。我们知道toArray()返回Object[]，所以为了在我们需要的数据类型中转换它，我们可以使用Arrays.copyOf方法。

Object[] objArray = Stream.of("AA", "BB", "CC").toArray();
String[] stArray = Arrays.copyOf(objArray, objArray.length, String[].class);

for(String s : stArray) {
  System.out.println(s);
} 

输出将是AA BB CC。

例2：在这个例子中，我们将把整数流转换成整数数组。

Object[] objArray = Stream.of(10, 20, 30, 40).toArray();
Integer[] intArray = Arrays.copyOf(objArray, objArray.length, Integer[].class);

for(Integer i : intArray) {
  System.out.println(i);
} 

输出将是10 20 30 40。

3.Using IntStream.toArray()
IntStream是int-valued元素的流。IntStream.toArray()方法将int值流转换为int数组。

int[] toArray() 

我们可以通过以下三种方式获得IntStream对象

IntStream intStream = IntStream.of(1,2,3,4,5); 

IntStream intStream = IntStream.rangeClosed(1, 5); 

IntStream intStream = Stream.of(4,5,6,7,8).mapToInt(i -> i);

现在让我们来讨论一些使用IntStream.toArray()方法的例子。

示例1：

int[] intArray = IntStream.of(10, 20, 30, 40).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出为10 20 30 40。

示例2：

int[] intArray = IntStream.rangeClosed(10, 15).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出为10 11 12 13 14 15。

示例3：

int[] intArray = Stream.of(3,4,5,6).mapToInt(i -> i * 2).toArray();
for(Integer i : intArray) {
  System.out.println(i);
} 

输出为6 8 10 12。

4.Using Collectors.toList()
我们可以将流转换为列表，然后将列表转换为数组。要将stream转换成list，我们需要对stream使用collect(Collectors.toList())。为了
将list转换成array，我们可以使用List.toArray方法。
*/
/*
public class Stream转成Array {
  public static void main(String[] args) {
	System.out.println("--- For String ---");
	String[] ar = Stream.of("Java", "Angular", "Spring")
		.collect(Collectors.toList())
		.toArray(new String[0]);
	
	for(String e : ar) {
	    System.out.println(e);	  
	}
	
	System.out.println("--- For Integer ---");
	Integer[] intArray = Stream.of(15, 20, 30)
		.map(e -> e * 2)
		.collect(Collectors.toList())
		.toArray(new Integer[0]);
	
        for(Integer i : intArray) {
            System.out.println(i);
        }	
  }
} 
*/
/*
输出

--- For String ---
Java
Angular
Spring
--- For Integer ---
30
40
60 
*/